package com.yidu.hbats.action.atsData;


import com.yidu.hbats.model.*;
import com.yidu.hbats.service.atsBase.AtsBaseItemService;
import com.yidu.hbats.service.atsBase.AtsBaseSportItemService;
import com.yidu.hbats.service.atsBase.AtsBaseSportService;
import com.yidu.hbats.service.atsData.AtsDataBatchService;
import com.yidu.hbats.service.atsData.AtsDataService;
import com.yidu.hbats.service.emp.AtsEmpAthleteService;
import com.yidu.utils.AtsDataShowTree;
import org.springframework.stereotype.Controller;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;
import java.util.*;

/**
 * 胡家福
 */
@Controller
@RequestMapping("/AtsDataShowController")
public class AtsDataShowController {
    /**
     * 运动员service
     */
    @Resource
    private AtsEmpAthleteService atsEmpAthleteService;
    /**
     * 体育项目关联指标service
     */
    @Resource
    private AtsBaseSportItemService atsBaseSportItemService;

    /**
     * 数据批次service
     */
    @Resource
    private AtsDataBatchService atsDataBatchService;

    /**
     * 实际数据service
     */
    @Resource
    private AtsDataService atsDataService;

    /**
     * 指标service
     */
    @Resource
    private AtsBaseItemService atsBaseItemService;
    /**
     * 体育项目service
     */
    @Resource
    private AtsBaseSportService atsBaseSportService;
    /**
     *根据运动员查体育项目
     * @param athleteId
     * @return
     */
    @RequestMapping("selectitem")
    @ResponseBody
    public  Map<String,Object> selectitem(String athleteId){
        int i=1;
    Map<String,Object> map=new HashMap<String,Object>();
        List<AtsBaseSport> lis=new ArrayList<AtsBaseSport>();
        List<AtsEmpAthlete> sd=new ArrayList<AtsEmpAthlete>();
        if (athleteId.indexOf(",")!=-1){
            for (String s : athleteId.split(",")) {

                sd.add( atsEmpAthleteService.findById(Integer.valueOf(s)));
               // System.out.println(atsEmpAthleteService.findById(Integer.valueOf(s)).getAthleteName());
                lis.add(atsBaseSportService.selectAth(Integer.valueOf(s)));
          }

        }else{
            lis.add(atsBaseSportService.selectAth(Integer.valueOf(athleteId)));
            sd.add( atsEmpAthleteService.findById(Integer.valueOf(athleteId)));
        }
        for (AtsBaseSport li : lis) {
            if(li.getSportId()!=lis.get(0).getSportId()) {
                i=0;
            }
        }
            if(i==0){
                map.put("num",0);
            }else{
                map.put("num",1);
                map.put("sportId",lis.get(0).getSportId());
                map.put("data",sd);
            }
        return map;
    }

    /**
     * 根据教练员ID查询运动员  返回list
     * @param atsEmpAthlete
     * @return
     */

    @RequestMapping("selectBysportId")
    @ResponseBody
    public List<Map<String,Object>> selectBysportId(AtsEmpAthlete atsEmpAthlete,String athleteIds){


        List<AtsEmpAthlete> list=atsEmpAthleteService.selectBysportId(atsEmpAthlete);
        List<Map<String,Object>> lis=new ArrayList<Map<String,Object>>();
        for (Iterator<AtsEmpAthlete> iterator = list.iterator(); iterator.hasNext(); ) {
            AtsEmpAthlete next =  iterator.next();
            Map<String,Object> map=new HashMap<>();
            map.put("name",next.getAthleteName());
            map.put("value",next.getAthleteId());
            if(!StringUtils.isEmpty(athleteIds)){
                if(athleteIds.indexOf(",")!=-1) {
                   String[] arr = athleteIds.split(",");
                    for (String str : arr) {
                        System.out.println(next.getAthleteId()+"=========="+str);
                        if (next.getAthleteId()==Integer.valueOf(str)){
                            map.put("selected",true);
                            break;
                        }
                    }
                }else {
                    if (next.getAthleteId()==Integer.valueOf(athleteIds)){
                        map.put("selected",true);

                    }
                }
            }
            lis.add(map);
        }
        return lis;
    }
    /**
     * 根据体育项目查询指标
     * @param sportId 体育项目ID
     * @return 树状参数
     */
    @RequestMapping("selectAtsBaseItem")
    @ResponseBody
    public List<Map<String,Object>> selectAtsBaseItem(Integer sportId){
        List<AtsBaseItem> atsBaseItemList= atsBaseItemService.selectSportIdItem(sportId);

        //新建树状图工具集合
        List<AtsDataShowTree> atsBaseItemTreeList=new ArrayList<>();
        //循环数据库数据
        for (AtsBaseItem atsBaseSportItem : atsBaseItemList) {
            AtsDataShowTree atsBaseItemTree=new AtsDataShowTree();
            //当前id
            atsBaseItemTree.setId(atsBaseSportItem.getItemId().toString());
            //名称
            atsBaseItemTree.setLabel(atsBaseSportItem.getItemExp());
            //外键
            atsBaseItemTree.setValue(atsBaseSportItem.getParentId().toString());
            //存入树状图工具集合
            atsBaseItemTreeList.add(atsBaseItemTree);
        }
        List<Map<String,Object>> lis=new ArrayList<Map<String,Object>>();
        Map<String,Object> map=new HashMap<>();
        map.put("label","指标");
        map.put("id",0);
        map.put("children",createTree(atsBaseItemTreeList));
        lis.add(map);
        return lis;
    }

    /**
     * 根据运动员ID查询数据批次  返回list
     * @param atsDataBatch
     * @return
     */
    @RequestMapping("selectAtsDataComparison")
    @ResponseBody
    public List<Map<String,Object>> selectAtsDataComparison(AtsDataBatch atsDataBatch, Integer batchIds){
        List<AtsDataBatch> list=atsDataBatchService.selectAtsDataComparison(atsDataBatch);
        List<Map<String,Object>> lis=new ArrayList<Map<String,Object>>();
        for (Iterator<AtsDataBatch> iterator = list.iterator(); iterator.hasNext(); ) {
            AtsDataBatch next =  iterator.next();
            Map<String,Object> map=new HashMap<>();
            map.put("name",next.getAthleteName()+"("+next.getBatchDate()+")");
            map.put("value",next.getBatchId());
            if(!StringUtils.isEmpty(batchIds)){
                if(next.getBatchId()==batchIds){
                    map.put("selected",true);
                }
            }
            lis.add(map);
        }
        return lis;
    }

    /**
     * 根据批次ID查批次
     * @param batchId
     * @return
     */
    @RequestMapping("selectBatchId")
    @ResponseBody
public AtsDataBatch selectBatchId(String batchId){
    AtsDataBatch atsDataBatch=new AtsDataBatch();
    atsDataBatch.setBatchId(Integer.valueOf(batchId));
    return   atsDataBatchService. selectAtsDataCondition(atsDataBatch);
}

    /**
     * 查比较数据  返回list
     * @param
     * @return
     */

    @RequestMapping("select")
    @ResponseBody
    public List<Map<String,Object>> select(String yudo,String zhibiao,String cishu,Integer sportId){
        String[] zhi=zhibiao.split(",");
        List<AtsBaseItem> atsBaseItemList=atsBaseItemService.selectSportIdItem(sportId);


        List<Map<String,Object>> lis=new ArrayList<Map<String,Object>>();
       // atsDataBatchService.selectAtsDataCondition(atsDataBatch);
        String[] arr=cishu.split(",");
        for (String s : arr) {
            if (!StringUtils.isEmpty(s)){
                List<AtsDataShowTree> atsBaseItemTreeList=new ArrayList<>();
                //循环数据库数据
                for (AtsBaseItem atsBaseSportItem : atsBaseItemList) {
                    AtsDataShowTree atsBaseItemTree=new AtsDataShowTree();
                    //当前id
                    atsBaseItemTree.setId(atsBaseSportItem.getItemId().toString());
                    //名称
                    atsBaseItemTree.setName(atsBaseSportItem.getItemExp());
                    //外键
                    atsBaseItemTree.setTitle(atsBaseSportItem.getParentId().toString());
                    //指标单位
                    atsBaseItemTree.setLabel(atsBaseSportItem.getItemUnit());
                  //  System.out.println("指标");
                    // atsBaseItemTree.setValue();
                    //存入树状图工具集合
                    atsBaseItemTreeList.add(atsBaseItemTree);
                }
                List<AtsDataShowTree> atsBaseItemTreeLists =createTree2(atsBaseItemTreeList);
                AtsDataBatch atsDataBatch=new AtsDataBatch();
                atsDataBatch.setBatchId(Integer.valueOf(s));
                atsDataBatch=  atsDataBatchService. selectAtsDataCondition(atsDataBatch);
                List<AtsData> atsData=atsDataService.atsDataByIdBatch(Integer.valueOf(s));
                for (int i=0; i<atsData.size();i++) {
                    int fg=0;
                    for (String  str: zhi) {
                       // System.out.println(atsData.get(i).getItemId()+"=="+str);
                        if (!StringUtils.isEmpty(str)) {
                            if (atsData.get(i).getItemId().toString() .equals( str)) {
                                fg = 1;
                            }
                        }
                    }
                    if(fg==0){
                       // System.out.println(atsData.get(i).getItemId()+"指标移除");
                        atsData.remove(i);
                        i--;
                    }
                }
                List<AtsDataShowTree> jieguo=sdf(atsBaseItemTreeLists,atsData);
                Map<String,Object> map=new HashMap<String,Object>();
                if(yudo.split(",").length==1){
                    map.put("name",atsDataBatch.getBatchDate());
                }else {
                    map.put("name", atsDataBatch.getAthleteName());
                }
                map.put("data",jieguo);
                lis.add(map);
            }

        }

        return lis;
    }

public  List<AtsDataShowTree> sdf(  List<AtsDataShowTree> atsBaseItemTreeLists ,List<AtsData> atsData){

    for (int i=0;i<atsBaseItemTreeLists.size() ;i++ ) {
       // System.out.println(atsBaseItemTreeLists.get(i).getName()+"--------"+atsBaseItemTreeLists.get(i).getChildren());
        if (atsBaseItemTreeLists.get(i).getChildren().size()>0){
            sdf(atsBaseItemTreeLists.get(i).getChildren(), atsData);
           // System.out.println(atsBaseItemTreeLists.get(i).getName()+"的长度"+atsBaseItemTreeLists.get(i).getChildren().size());
            if (atsBaseItemTreeLists.get(i).getChildren().size()==0){
               // System.out.println(atsBaseItemTreeLists.get(i).getName()+"移除");
                atsBaseItemTreeLists.remove(i);
                i--;
            }
        }else{
            int j=0;
           // System.out.println(atsData+",.,.,");
            for (AtsData s : atsData) {
               // System.out.println(atsBaseItemTreeLists.get(i).getId()+"!!!!!"+s.getItemId());
                if(atsBaseItemTreeLists.get(i).getId().equals(s.getItemId().toString())){
                 //   System.out.println(atsBaseItemTreeLists.get(i).getName()+"值"+s.getValueFact());
                    atsBaseItemTreeLists.get(i).setValue(s.getValueFact().toString());
                    j=1;
                }
            }
            if (j==0){
               // System.out.println(atsBaseItemTreeLists.get(i).getName()+"根移除");
                atsBaseItemTreeLists.remove(i);

                i--;
            }
        }
      //  System.out.println("还剩"+atsBaseItemTreeLists);
    }

return atsBaseItemTreeLists;
}
    /**
     * 下拉树
     * @param nodes
     * @return
     */
    public List<AtsDataShowTree> createTree(List<AtsDataShowTree> nodes) {


        if (nodes == null || nodes.size() < 0){
            return null;
        }
        List<AtsDataShowTree> nodeList = new ArrayList<>();// 根节点自定义，但是要和pid对应好
        // 将所有节点添加到多叉树中
        for (AtsDataShowTree node : nodes) {
            if (node.getValue().equals("0")) {// 根节点自定义，但是要和pid对应好
                // 向根添加一个节点
                nodeList.add(node);
            } else {
                for (AtsDataShowTree item : nodes) {
                    if (item.getId().equals(node.getValue())) {
                        item.getChildren().add(node);
                        //item.setData(item.getChildren());
                        break ;
                    }
                }
            }

        }

        return nodeList;
    }

    /**
     * 下拉树2
     * @param nodes
     * @return
     */
    public List<AtsDataShowTree> createTree2(List<AtsDataShowTree> nodes) {
        System.out.println("cao===="+nodes);

        if (nodes == null || nodes.size() < 0){
            return null;
        }
        List<AtsDataShowTree> nodeList = new ArrayList<>();// 根节点自定义，但是要和pid对应好
        // 将所有节点添加到多叉树中
        for (AtsDataShowTree node : nodes) {
            if (node.getTitle().equals("0")) {// 根节点自定义，但是要和pid对应好
                // 向根添加一个节点
                nodeList.add(node);
            } else {
                for (AtsDataShowTree item : nodes) {
                    if (item.getId().equals(node.getTitle())) {
                        item.getChildren().add(node);
                       // item.setData(item.getChildren());
                        break ;
                    }
                }
            }

        }

         return nodeList;
}

}
